\input texinfo    @c -*- texinfo -*-
@c %**start of header
@setfilename list.info
@settitle Guile Awesome List
@documentencoding UTF-8
@documentlanguage en
@c %**end of header

@finalout
@titlepage
@title Guile Awesome List
@author Zelphir Kaltstahl (help & input from Guile community)
@end titlepage

@contents

@ifnottex
@node Top
@top Guile Awesome List
@end ifnottex

@menu
* Manuals::
* Tutorials / Guides / Books::
* Libraries::
* Projects::
* Programming paradigm::
* Tools::
* Blogs::
* Other: Other (5). 
* Other lists of Guile software::
* Videos / Talks / Presentations::

@detailmenu
--- The Detailed Node Listing ---

Tutorials / Guides / Books

* General GNU Guile / Scheme::
* Macros::
* Monads::
* FFI - Foreign Function Interface::

Macros

* CK macros::

Libraries

* Async::
* Browser::
* Chat::
* Compression::
* Computer vision::
* Configuration::
* Cryptography::
* Databases::
* Data structures::
* Development environments::
* Device management::
* Distributed computing::
* E-Mail::
* Event loop::
* FFI - Foreign Function Interface: FFI - Foreign Function Interface (1). 
* File formats::
* File system::
* Game development::
* Games::
* Genomics::
* Graphics::
* GUI development::
* Language::
* Logging::
* Machine Learning::
* Macros: Macros (1). 
* Message Queues::
* Network programming::
* Parallelism::
* Parsing::
* Plotting::
* Protocols::
* Serialization formats::
* SRFI (Scheme Request For Implementation) implementations::
* Strings::
* Syntax::
* Regular expressions::
* REPL (Read Eval Print Loop)::
* RPC (Remote Procedure Call)::
* Scientific computing and mathematics::
* Search engine::
* TUI development::
* Unit Testing::
* Version control systems::
* Web Development::
* Window manager::
* Working with code::
* Other::

Chat

* Chat clients::
* Chat bots::

Databases

* Generic::
* Postgres::
* Sqlite::
* MySQL::
* Redis::
* CouchDB::
* Other: Other (1). 

Data structures

* Purely functional data structures (PDFS)::
* RDF::
* Lenses::
* Other: Other (2). 

File formats

* JSON::
* CSV::
* XML::
* Markdown::
* Texinfo::
* JPEG::
* ICS::
* torrent::
* Other: Other (3). 

Graphics

* Image processing::

Parsing

* Parser Combinators::
* Parser Generator::
* Other: Other (4). 

Scientific computing and mathematics

* Interaction with the Jupyter ecosystem::

Unit Testing

* TAP output::

Web Development

* Web frameworks::
* Tooling / Additional libraries::
* Static website generators::
* Template engine::
* Interaction with services::
* Web application examples::
* Web drivers / Selenium::

Programming paradigm

* "Object-oriented programming"::
* Relational programming::
* Functional programming::

"Object-oriented programming"

* Prototype based::

Tools

* Editor support::
* Project management::

Project management

* Package managers::

@end detailmenu
@end menu

@node Manuals
@chapter Manuals

@itemize
@item
There is a huge reference manual for GNU Guile on the GNU website: @uref{https://www.gnu.org/software/guile/manual/}.
@end itemize

@node Tutorials / Guides / Books
@chapter Tutorials / Guides / Books

@menu
* General GNU Guile / Scheme::
* Macros::
* Monads::
* FFI - Foreign Function Interface::
@end menu

@node General GNU Guile / Scheme
@section General GNU Guile / Scheme

@itemize
@item
Guile reference manual
@itemize
@item
website: @uref{https://www.gnu.org/software/guile/manual/}
@end itemize

@item
official Guile tutorial
@itemize
@item
website: @uref{https://www.gnu.org/software/guile/docs/guile-tut/tutorial.html}
@end itemize

@item
Structure and Interpretation of Computer Programs (SICP)
@itemize
@item
website: @uref{https://mitpress.mit.edu/sites/default/files/sicp/index.html}
@item
PDF version: @uref{https://github.com/sarabander/sicp-pdf}
@end itemize

@item
The Little Schemer
@itemize
@item
website: @uref{https://mitpress.mit.edu/books/little-schemer-fourth-edition}
@end itemize

@item
"Learn Scheme in 15 minutes"
@itemize
@item
website: @uref{https://web-artanis.com/scheme.html}
@end itemize

@item
guile-tutorial
@itemize
@item
git repo: @uref{https://notabug.org/cwebber/guile-tutorial}
@end itemize

@item
Guile Hacker Handbook
@itemize
@item
website: @uref{https://jeko.frama.io/en/index.html}
@item
git repo: @uref{https://framagit.org/Jeko/jeko.frama.io}
@end itemize

@item
The Scheme Programming Language
@itemize
@item
web version: @uref{https://scheme.com/tspl4/}
@end itemize

@item
A Pamphlet Against R
@itemize
@item
PDF version: @uref{https://github.com/panicz/pamphlet/raw/master/pamphlet.pdf}
@item
source codes: @uref{https://github.com/panicz/pamphlet}
@end itemize
@end itemize

@node Macros
@section Macros

@itemize
@item
Macros in the GNU Guile reference manual
@itemize
@item
website: @uref{https://www.gnu.org/software/guile/manual/html_node/Macros.html}
@end itemize

@item
Writing Hygienic Macros in Scheme with Syntax-Case
@itemize
@item
article: @uref{https://doc.lagout.org/programmation/Lisp/Scheme/Programming%20With%20Hygienic%20Macros%20-%20R%20K%20Dybvig.pdf}
@end itemize

@item
Community Scheme Wiki about macros
@itemize
@item
scheme-faq-macros
@itemize
@item
website: @uref{http://community.schemewiki.org/?scheme-faq-macros}
@end itemize
@item
syntax-case
@itemize
@item
website: @uref{http://community.schemewiki.org/?syntax-case}
@end itemize
@end itemize

@item
A Scheme Syntax-Rules Primer
@itemize
@item
website: @uref{http://www.willdonnelly.net/blog/scheme-syntax-rules/}
@end itemize

@item
Macro-by-Example: Deriving Syntactic Transformations from their Specifications
@itemize
@item
paper: @uref{https://legacy.cs.indiana.edu/ftp/techreports/TR206.pdf}
@end itemize

@item
wikibooks.org about macros
@itemize
@item
website: @uref{https://en.wikibooks.org/wiki/Scheme_Programming/Macros}
@end itemize

@item
Advanced Scheme Techniques - Some Naughty Bits
@itemize
@item
slides: @uref{http://people.csail.mit.edu/jhbrown/scheme/macroslides04.pdf}
@end itemize

@item
C2 Wiki Scheme Macro Examples
@itemize
@item
website: @uref{http://wiki.c2.com/?SchemeMacroExamples}
@end itemize

@item
JRM's Syntax-rules Primer for the Merely Eccentric
@itemize
@item
website: @uref{https://hipster.home.xs4all.nl/lib/scheme/gauche/define-syntax-primer.txt}
@itemize
@item
another location: @uref{http://www.phyast.pitt.edu/~micheles/syntax-rules.pdf}
@end itemize
@end itemize

@item
Scheme Macros I: Modules
@itemize
@item
website: @uref{https://blog.veitheller.de/Scheme_Macros_I:_Modules.html}
@end itemize

@item
Writing Macros in Continuation-Passing Style
@itemize
@item
paper: @uref{https://www.semanticscholar.org/paper/Writing-Macros-in-Continuation-Passing-Style-Hilsdale-Friedman/752575dc24b2bb6e74ee6146df71860e10e3aee9#citing-papers} (TODO: find a more permanent looking link)
@end itemize

@item
Low- and high-level macro programming in Scheme
@itemize
@item
website: @uref{http://okmij.org/ftp/Scheme/macros.html}
@end itemize
@end itemize

@menu
* CK macros::
@end menu

@node CK macros
@subsection CK macros

@itemize
@item
Applicative syntax-rules: macros that compose better
@itemize
@item
website: @uref{http://okmij.org/ftp/Scheme/macros.html#ck-macros}
@end itemize

@item
Chicken Scheme Wiki about ck-macros
@itemize
@item
website: @uref{http://wiki.call-cc.org/eggref/5/ck-macros}
@end itemize
@end itemize

@node Monads
@section Monads

@itemize
@item
A Schemer's Introduction to Monads
@itemize
@item
website: @uref{http://www.ccs.neu.edu/home/dherman/research/tutorials/monads-for-schemers.txt}
@end itemize

@item
A Schemer’s View of Monads - Partial Draft
@itemize
@item
website: @uref{https://cgi.sice.indiana.edu/~c311/lib/exe/fetch.php?media=manymonads.pdf}
@end itemize

@item
Monadic Programming in Scheme
@itemize
@item
website: @uref{http://okmij.org/ftp/Scheme/monad-in-Scheme.html}
@end itemize

@item
Panicz Godek's answer to How would you explain a concept of monads to a non-CS person?
@itemize
@item
website @uref{https://www.quora.com/How-would-you-explain-a-concept-of-monads-to-a-non-CS-person/answer/Panicz-Godek}
@end itemize

@item
Panicz Godek's answer to @uref{https://www.quora.com/Why-do-so-many-programmers-not-understand-the-theory-of-monads/answer/Panicz-Godek}
@itemize
@item
website @uref{https://www.quora.com/Why-do-so-many-programmers-not-understand-the-theory-of-monads/answer/Panicz-Godek}
@end itemize
@end itemize

@node FFI - Foreign Function Interface
@section FFI - Foreign Function Interface

@itemize
@item
GNU Guile standard library FFI
@itemize
@item
GNU software reference manual: @uref{https://www.gnu.org/software/guile/manual/html_node/Foreign-Function-Interface.html}
@end itemize
@end itemize

@node Libraries
@chapter Libraries

@menu
* Async::
* Browser::
* Chat::
* Compression::
* Computer vision::
* Configuration::
* Cryptography::
* Databases::
* Data structures::
* Development environments::
* Device management::
* Distributed computing::
* E-Mail::
* Event loop::
* FFI - Foreign Function Interface: FFI - Foreign Function Interface (1). 
* File formats::
* File system::
* Game development::
* Games::
* Genomics::
* Graphics::
* GUI development::
* Language::
* Logging::
* Machine Learning::
* Macros: Macros (1). 
* Message Queues::
* Network programming::
* Parallelism::
* Parsing::
* Plotting::
* Protocols::
* Serialization formats::
* SRFI (Scheme Request For Implementation) implementations::
* Strings::
* Syntax::
* Regular expressions::
* REPL (Read Eval Print Loop)::
* RPC (Remote Procedure Call)::
* Scientific computing and mathematics::
* Search engine::
* TUI development::
* Unit Testing::
* Version control systems::
* Web Development::
* Window manager::
* Working with code::
* Other::
@end menu

@node Async
@section Async

@itemize
@item
8sync
@itemize
@item
git repository at Savannah: @uref{https://savannah.gnu.org/projects/8sync}
@item
manual / GNU software manual: @uref{https://www.gnu.org/software/8sync/manual/html_node/index.html#Top}
@item
website / GNU software page: @uref{https://www.gnu.org/software/8sync/}
@item
tutorial: @uref{https://www.gnu.org/software/8sync/manual/html_node/Tutorial.html#Tutorial}
@end itemize
@end itemize

@node Browser
@section Browser

@itemize
@item
Nomad
@itemize
@item
git repository at non-GNU Savannah: @uref{https://savannah.nongnu.org/projects/nomad/}
@item
website: @uref{https://www.nongnu.org/nomad/}
@end itemize
@end itemize

@node Chat
@section Chat

@menu
* Chat clients::
* Chat bots::
@end menu

@node Chat clients
@subsection Chat clients

@enumerate
@item
IRC


@itemize
@item
@code{guile-irc}
@itemize
@item
git repository at GitHub: @uref{https://github.com/rekado/guile-irc}
@item
description: @emph{"An irc library for GNU guile."} (@uref{https://github.com/rekado/guile-irc/blob/master/README})
@item
API reference manual: @uref{http://fbs.github.io/guile-irc/}
@end itemize
@end itemize
@end enumerate

@node Chat bots
@subsection Chat bots

@enumerate
@item
IRC


@itemize
@item
Cunning Bot
@itemize
@item
description:
@quotation
Cunning Bot is a command-oriented IRC bot written in Guile Scheme.

(@uref{https://github.com/cadrspace/cunning-bot/blob/cadrobot/README})

@end quotation
@item
git repo: @uref{https://github.com/cadrspace/cunning-bot}
@end itemize
@end itemize
@end enumerate

@node Compression
@section Compression

@itemize
@item
@code{guile-zlib}
@itemize
@item
git repository at GitHub: @uref{https://github.com/davexunit/guile-zlib}
@end itemize
@end itemize

@node Computer vision
@section Computer vision

@itemize
@item
GNU Guile-CV
@itemize
@item
website: @uref{https://www.gnu.org/software/guile-cv/}
@item
GNU software reference manual: @uref{https://www.gnu.org/software/guile-cv/manual/html_node/index.html}
@item
description:
@quotation
Guile-CV - Image Processing and Analysis in Guile - is a Computer Vision functional programming library for the Guile Scheme language.

Guile-CV is based on Vigra (Vision with Generic Algorithms), enhanced with additional algorithms (Image Textures, Delineate, Reconstruction and many more), all accessible through a nice, clean and easy to use high level API@.

Guile-CV is natively multi-threaded, and takes advantage of multiple cores, using high-level and fine grained application-level parallelism constructs available in Guile, based on its support to POSIX threads.

(@uref{https://www.gnu.org/software/guile-cv/index.html})

@end quotation
@end itemize
@end itemize

@node Configuration
@section Configuration

@itemize
@item
@code{guile-config}
@itemize
@item
git repository at GitLab: @uref{https://gitlab.com/a-sassmannshausen/guile-config}
@end itemize
@end itemize

@node Cryptography
@section Cryptography

@itemize
@item
@code{guile-gcrypt}
@itemize
@item
git repo: @uref{https://notabug.org/cwebber/guile-gcrypt}
@item
description:
@quotation
    Guile-Gcrypt provides a Guile 3.x/2.x interface to a subset of the GNU
Libgcrypt crytographic library, which is itself used by the GNU Privacy Guard
(GPG).

    Guile-Gcrypt provides modules for cryptographic hash functions, message
authentication codes (MAC), public-key cryptography, strong randomness, and
more. It is implemented using the foreign function interface (FFI) of Guile.

@end quotation
@end itemize
@end itemize

@node Databases
@section Databases

@menu
* Generic::
* Postgres::
* Sqlite::
* MySQL::
* Redis::
* CouchDB::
* Other: Other (1). 
@end menu

@node Generic
@subsection Generic

@itemize
@item
Generic
@itemize
@item
@code{guile-dbi}
@itemize
@item
git repository at GitHub: @uref{https://github.com/opencog/guile-dbi}
@item
documentation: @uref{https://htmlpreview.github.io/?https://github.com/opencog/guile-dbi/blob/master/website/guile-dbi.html}
@item
offers MySQL, Postgresql and SQLite3 interfaces
@end itemize
@end itemize
@end itemize

@node Postgres
@subsection Postgres

@itemize
@item
@code{guile-squee}
@itemize
@item
git repository at notabug.org: @uref{https://notabug.org/cwebber/guile-squee}
@item
documentation at: ???
@end itemize

@item
@code{guile-dbd-postgresql}
@itemize
@item
git repository: @uref{https://github.com/opencog/guile-dbi/tree/master/guile-dbd-postgresql}
@item
documentation: @uref{https://github.com/opencog/guile-dbi/blob/master/guile-dbd-postgresql/README}
@item
description: This is a sub-repository of @code{guile-dbi} which is used for dealing with the Postgres side of things.
@end itemize
@end itemize

@node Sqlite
@subsection Sqlite

@itemize
@item
@code{guile-sqlite3}
@itemize
@item
git repository at notabug.org: @uref{https://notabug.org/guile-sqlite3/guile-sqlite3.git}
@item
documentation at: ???
@end itemize

@item
@code{guile-dbd-sqlite3}
@itemize
@item
git repository at GitHub: @uref{https://github.com/opencog/guile-dbi/tree/master/guile-dbd-sqlite3}
@item
documentation: @uref{https://github.com/opencog/guile-dbi/blob/master/guile-dbd-sqlite3/README}
@item
description: This is a sub-repository of @code{guile-dbi} which is used for dealing with the Sqlite3 side of things.
@end itemize
@end itemize

@node MySQL
@subsection MySQL

@itemize
@item
@code{guile-dbd-mysql}
@itemize
@item
git repository at GitHub: @uref{https://github.com/opencog/guile-dbi/tree/master/guile-dbd-mysql}
@item
documentation: @uref{https://github.com/opencog/guile-dbi/blob/master/guile-dbd-mysql/README}
@item
description: This is a sub-repository of @code{guile-dbi} which is used for dealing with the MySQL side of things.
@end itemize
@end itemize

@node Redis
@subsection Redis

@itemize
@item
@code{guile-redis}
@itemize
@item
git repository at GitHub: @uref{https://github.com/aconchillo/guile-redis}
@end itemize
@end itemize

@node CouchDB
@subsection CouchDB

@itemize
@item
CouchDB
@itemize
@item
@code{guile-couchdb}
@item
git repo: @uref{https://github.com/ukulanne/guile-couchdb}
@item
description: CouchDB bindings for Guile
@end itemize
@end itemize

@node Other (1)
@subsection Other

@itemize
@item
WiredTiger (@uref{http://www.wiredtiger.com/}
@itemize
@item
@code{guile-wiredtiger}
@itemize
@item
blog post: @uref{https://hyper.dev/blog/getting-started-with-guile-wiredtiger.html}
@item
git repository at: ??? (framagit requires login?)
@end itemize
@end itemize

@item
@code{guile-sparql}: @uref{https://github.com/roelj/guile-sparql}

@item
@code{sparqling-genomics}: @uref{https://github.com/UMCUGenetics/sparqling-genomics}

@item
@code{nomunofu}
@itemize
@item
mentioned on: @uref{https://hyper.dev/blog/nomunofu.html}
@item
git repo: ???
@end itemize
@end itemize

@node Data structures
@section Data structures

@menu
* Purely functional data structures (PDFS)::
* RDF::
* Lenses::
* Other: Other (2). 
@end menu

@node Purely functional data structures (PDFS)
@subsection Purely functional data structures (PDFS)

@itemize
@item
@code{pdfs}
@itemize
@item
git repository at GitHub: @uref{https://github.com/ijp/pfds}
@item
documentation: ???
@end itemize

@item
@code{fectors}
@itemize
@item
git repository at GitHub: @uref{https://github.com/ijp/fectors}
@end itemize
@end itemize

@node RDF
@subsection RDF

@itemize
@item
@code{guile-rdf}
@itemize
@item
git repository at framagit: @uref{https://framagit.org/tyreunom/guile-rdf}
@end itemize
@end itemize

@node Lenses
@subsection Lenses

@itemize
@item
@code{guile-lens}
@itemize
@item
git repository at GitLab: @uref{https://gitlab.com/a-sassmannshausen/guile-lens}
@end itemize
@end itemize

@node Other (2)
@subsection Other

@itemize
@item
@code{copernic}
@itemize
@item
git repository at GitHub: @uref{https://github.com/amirouche/copernic}
@end itemize

@item
@code{scheme-bytestructures}
@itemize
@item
git repo: @uref{https://github.com/TaylanUB/scheme-bytestructures}
@item
description:
@quotation
[@dots{}] offers a system imitating the type system of the C programming language, to be used on bytevectors. C's type system works on raw memory, and ours works on bytevectors which are an abstraction over raw memory in Scheme. The system is in fact more powerful than the C type system, elevating types to first-class status.

@end quotation
@end itemize

@item
@code{guile-newra}
@itemize
@item
git repo: @uref{https://github.com/lloda/guile-newra}
@item
description: "A Scheme replacement for Guile's array system" (@uref{https://github.com/lloda/guile-newra})
@end itemize

@item
Treaps
@itemize
@item
website: @uref{http://okmij.org/ftp/Scheme/#treaps}
@item
description:
@quotation
An ordered dictionary data structure, based on randomized search trees (treaps) by Seidel and Aragon. Compared to red-black trees, treap is simpler and more elegant, and can get by without sentinels.

(@uref{http://okmij.org/ftp/Scheme/#treaps})

@end quotation
@end itemize
@end itemize

@node Development environments
@section Development environments

@itemize
@item
@code{guile-studio}
@itemize
@item
git repo: @uref{https://git.elephly.net/gitweb.cgi?p=software/guile-studio.git;a=tree}
@item
description:
@quotation
Racket has Dr Racket.  Guile has @dots{} Emacs?  This is Emacs with a few
settings that make working with Guile easier for people new to Emacs.
Features include: CUA mode, Geiser, tool bar icons to evaluate Guile
buffers, support for Guile's very own picture language, code completion, a
simple mode line, etc. [@dots{}]

@end quotation
(@uref{https://git.elephly.net/gitweb.cgi?p=software/guile-studio.git;a=blob;f=README.org;hb=HEAD})
@end itemize
@end itemize

@node Device management
@section Device management

@itemize
@item
@code{guile-udev}:
@itemize
@item
description: @emph{"Guile-Udev is a GNU Guile bindings to libudev."} (@uref{https://github.com/artyom-poptsov/guile-udev/blob/master/README})
@item
git repo: @uref{https://github.com/artyom-poptsov/guile-udev}
@item
documentation: (inside the git repo: @uref{https://github.com/artyom-poptsov/guile-udev/blob/master/doc/guile-udev.texi})
@item
examples: (inside the git repo: @uref{https://github.com/artyom-poptsov/guile-udev/tree/master/examples})
@end itemize
@end itemize

@node Distributed computing
@section Distributed computing

@itemize
@item
@code{metabash}
@itemize
@item
git repository: @uref{https://github.com/artyom-poptsov/metabash}
@item
description: @emph{"GNU Guile module for running distributed shell pipelines."} -- @uref{https://github.com/artyom-poptsov/metabash/blob/master/README.org}
@end itemize
@end itemize

@node E-Mail
@section E-Mail

@itemize
@item
GNU Mailutils ??? (@uref{https://mailutils.org/})

@item
@code{guile-email}: @uref{https://guile-email.systemreboot.net/}
@end itemize

@node Event loop
@section Event loop

@itemize
@item
@code{guile-a-sync}
@itemize
@item
git repository at GitHub: @uref{https://github.com/ChrisVine/guile-a-sync}
@item
documentation: ?
@end itemize
@end itemize

@node FFI - Foreign Function Interface (1)
@section FFI - Foreign Function Interface

@itemize
@item
GNU Guile standard library FFI
@itemize
@item
GNU software reference manual: @uref{https://www.gnu.org/software/guile/manual/html_node/Foreign-Function-Interface.html}
@end itemize

@item
@code{ffi-helper} from NYACC
@itemize
@item
documentation: @uref{https://www.nongnu.org/nyacc/ffi-help.html}
@end itemize
@end itemize

@node File formats
@section File formats

@menu
* JSON::
* CSV::
* XML::
* Markdown::
* Texinfo::
* JPEG::
* ICS::
* torrent::
* Other: Other (3). 
@end menu

@node JSON
@subsection JSON

@itemize
@item
JSON
@itemize
@item
@code{guile-json}
@itemize
@item
on GitHub: @uref{https://github.com/aconchillo/guile-json}
@item
on savannah: @uref{http://savannah.nongnu.org/projects/guile-json/}
@end itemize
@end itemize
@end itemize

@node CSV
@subsection CSV

@itemize
@item
@code{guile-csv}
@itemize
@item
git repository at GitLab: @uref{https://gitlab.com/NalaGinrut/guile-csv}
@end itemize

@item
@code{guile-dsv}
@itemize
@item
This is more general, but can work with CSV as well.
@item
git repository at GitHub: @uref{https://github.com/artyom-poptsov/guile-dsv}
@end itemize
@end itemize

@node XML
@subsection XML

@itemize
@item
Guile's standard library SXML implementation
@itemize
@item
GNU software manual: @uref{https://www.gnu.org/software/guile/manual/html_node/SXML.html}
@item
Basically your templates become functions or macros.
@item
The structure of your document is kept as Scheme data structures.
@itemize
@item
This avoids having parse the document as a long string into an internal data structure to perform semantic transformations.
@item
It enables pattern matching without resorting to things like regular expressions and similar shenanigans.
@end itemize
@end itemize
@end itemize

@node Markdown
@subsection Markdown

@itemize
@item
@code{guile-commonmark}
@itemize
@item
git repository at GitHub: @uref{https://github.com/OrangeShark/guile-commonmark}
@item
documentation: ???
@end itemize
@end itemize

@node Texinfo
@subsection Texinfo

@itemize
@item
Guile standard library texinfo functionality
@itemize
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile/manual/html_node/texinfo.html}
@end itemize
@end itemize

@node JPEG
@subsection JPEG

@itemize
@item
@code{guile-jpeg}: a library for parsing JPEG files
@itemize
@item
git repository at GitHub: @uref{https://github.com/guildhall/guile-jpeg}
@end itemize
@end itemize

@strong{*}

@node ICS
@subsection ICS

@itemize
@item
@code{guile-ics}
@itemize
@item
git repository at GitHub: @uref{https://github.com/artyom-poptsov/guile-ics}
@end itemize
@end itemize

@node torrent
@subsection torrent

@itemize
@item
@code{torrent}
@itemize
@item
git repository at GitHub: @uref{https://github.com/o-nly/torrent}
@item
documentation at: ???
@end itemize
@end itemize

@node Other (3)
@subsection Other

@itemize
@item
If the input is not input from users and is trustworthy, one might be able to leverage read/write of s-expressions instead of using other formats.
@end itemize

@node File system
@section File system

@itemize
@item
@code{sdupes}, duplicate file detection
@itemize
@item
git repository at GitHub: @uref{https://github.com/sph-mn/sdupes}
@end itemize
@end itemize

@node Game development
@section Game development

@itemize
@item
Chickadee
@itemize
@item
describes itself as "game development toolkit"
@item
OpenGL based
@item
website: @uref{https://dthompson.us/projects/chickadee.html}
@item
manual: @uref{https://dthompson.us/manuals/chickadee/index.html}
@end itemize
@end itemize

@node Games
@section Games

@itemize
@item
StayAlive
@itemize
@item
git repo: @uref{https://github.com/mwitmer/StayAlive}
@end itemize

@item
dryads-wake
@itemize
@item
git repo: @uref{https://hg.sr.ht/~arnebab/dryads-wake}
@item
description:

@quotation
Dryads Wake is a game of dialogue and choices.
(@uref{https://hg.sr.ht/~arnebab/dryads-wake})

@end quotation
@end itemize
@end itemize

@node Genomics
@section Genomics

@itemize
@item
@code{sparqling-genomics}
@itemize
@item
git repo: @uref{https://github.com/UMCUGenetics/sparqling-genomics}
@item
description:
@quotation
This project provides programs to extract RDF triplets from commonly used file formats in genomics. It also provides a web-based environment to explore the RDF triplets once inserted in a triple store.

(@uref{https://github.com/UMCUGenetics/sparqling-genomics})

@end quotation
@item
usage example: @uref{https://github.com/UMCUGenetics/sparqling-genomics/blob/dc5fea515c30aa26ff60b77911438689473d125b/web/ldap/authenticate.scm.in#L148}
@end itemize
@end itemize

@node Graphics
@section Graphics

@itemize
@item
@code{guile-sdl}
@itemize
@item
GNU software page: @uref{https://www.gnu.org/software/guile-sdl/}
@item
gnuvola page of examples: @uref{http://www.gnuvola.org/software/guile-sdl-demos/}
@item
gnuvola software page: @uref{http://www.gnuvola.org/software/guile-sdl-demos/}
@end itemize

@item
@code{guile-sdl2}
@itemize
@item
project website: @uref{https://dthompson.us/projects/guile-sdl2.html}
@end itemize

@item
@code{guile-opengl}
@itemize
@item
GNU software page: @uref{https://www.gnu.org/software/guile-opengl/}
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile-opengl/manual/guile-opengl.html}
@item
git repository at Savannah: @uref{http://savannah.gnu.org/projects/guile-opengl}
@end itemize

@item
@code{guile-cairo}
@itemize
@item
git repository at Savannah: @uref{http://savannah.nongnu.org/projects/guile-cairo}
@end itemize

@item
@code{guile-jpeg}: a library for parsing JPEG files
@itemize
@item
git repository at GitHub: @uref{https://github.com/guildhall/guile-jpeg}
@end itemize
@end itemize

@menu
* Image processing::
@end menu

@node Image processing
@subsection Image processing

@itemize
@item
@code{guile-cv}
@itemize
@item
GNU software page: @uref{https://www.gnu.org/software/guile-cv/}
@item
git repository at Savannah: @uref{http://git.savannah.gnu.org/cgit/guile-cv.git}
@end itemize
@end itemize

@node GUI development
@section GUI development

@itemize
@item
@code{guile-gi}
@itemize
@item
git repository at GitHub: @uref{https://github.com/spk121/guile-gi}
@item
documentation at: @uref{https://spk121.github.io/guile-gi/}
@end itemize

@item
@code{guile-gnome}
@itemize
@item
GNU software page: @uref{https://www.gnu.org/software/guile-gnome/}
@item
git repository at Savannah: @uref{http://git.savannah.gnu.org/cgit/guile-gnome.git}
@end itemize

@item
@code{guile-gtk}
@itemize
@item
website: @uref{https://www.gnu.org/software/guile-gtk/}
@item
CVS repository at non-GNU Savannah: @uref{http://savannah.nongnu.org/projects/guile-gtk/}
@end itemize

@item
@code{g-golf}: @uref{https://www.gnu.org/software/g-golf/}
@end itemize

@node Language
@section Language

@itemize
@item
@code{guile-aspell}
@itemize
@item
git repository at GitHub: @uref{https://github.com/spk121/guile-aspell}
@item
website: @uref{http://lonelycactus.com/guile-aspell.html}
@end itemize
@end itemize

@node Logging
@section Logging

@itemize
@item
@code{guile-logging}
@itemize
@item
git repository at GitHub: @uref{https://github.com/shanecelis/guile-logging}
@end itemize

@item
SysLog proposal
@itemize
@item
git repo: @uref{https://bitbucket.org/cowan/r7rs-wg1-infra/src/default/SyslogCowan.md}
@item
description: This is a specification for an implementation of syslog.
@end itemize

@item
logging module of @code{sparqling-genomics}
@itemize
@item
git repo: @uref{https://github.com/UMCUGenetics/sparqling-genomics/blob/master/web/logger.scm}
@item
description: This is what @code{sparqling-genomics} uses internally.
@end itemize
@end itemize

@node Machine Learning
@section Machine Learning

@itemize
@item
decision tree
@itemize
@item
@code{guile-ml}
@itemize
@item
repository at notabug.org: @uref{https://notabug.org/ZelphirKaltstahl/guile-ml}
@end itemize
@end itemize

@item
@code{guile-snowball-stemmer}
@itemize
@item
mentioned on: @uref{https://snowballstem.org/projects.html}
@item
mentioned on: @uref{https://github.com/snowballstem/snowball/issues/34#issuecomment-491056371}
@item
git repo: unfortunately the link to the repository is broken
@end itemize

@item
AIscm
@itemize
@item
website: @uref{http://wedesoft.github.io/aiscm/}
@item
description:
@quotation
AIscm is a Guile extension for numerical arrays and tensors. Performance is achieved by using the LLVM JIT compiler.

(@uref{http://wedesoft.github.io/aiscm/})

@end quotation
@end itemize
@end itemize

@node Macros (1)
@section Macros

@itemize
@item
@code{guile-for-loops}
@itemize
@item
mercurial repo: @uref{https://hg.sr.ht/~bjoli/guile-for-loops}
@item
description:
@quotation
A re-implementation of a large-ish chunk of rackets for-macros. It is mostly compatible with racket's macros, with the largest omission being the body-or-break clause and some of the sequence iterators (like in-cycle, which can be covered by circular lists). There are other differences of course, like for/foldr not being on par feature-wise, and all the nicities you get by having a generic sequence interfce.

[@dots{}]

(@uref{https://hg.sr.ht/~bjoli/guile-for-loops/browse/README.md?rev=580d3fb365ea2734b037ad3ca7f2ab1e4aa5116d})

@end quotation
@end itemize

@item
@code{megacut} macro:
@itemize
@item
mercurial repo: @uref{https://hg.sr.ht/~bjoli/megacut}
@item
description:
@quotation
This is  a clojure-like lambda shorthand for guile. The macro is called megacut (which is a bad name, since it is not much like cut).

(@uref{https://hg.sr.ht/~bjoli/megacut/browse/readme.txt?rev=75caf96aa4a9282d489230fe56fff4f1aa5e2564})

@end quotation
@end itemize

@item
Documentation for Scheme Syntax Extension Packages in SLIB
@itemize
@item
website: @uref{https://people.csail.mit.edu/jaffer/slib/Scheme-Syntax-Extension-Packages.html#Scheme-Syntax-Extension-Packages}
@end itemize
@end itemize

@node Message Queues
@section Message Queues

@itemize
@item
Zero MQ
@itemize
@item
@code{guile-zmq}
@itemize
@item
git repository at GitLab: @uref{https://gitlab.com/NalaGinrut/guile-zmq}
@end itemize
@item
@code{guile-simple-zmq}
@itemize
@item
git repository at GitHub: @uref{https://github.com/jerry40/guile-simple-zmq}
@end itemize
@end itemize
@end itemize

@node Network programming
@section Network programming

@itemize
@item
Guile's standard library networking module
@itemize
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile/manual/html_node/Networking.html}
@end itemize

@item
@code{guile-curl}
@itemize
@item
git repository at GitHub: @uref{https://github.com/spk121/guile-curl}
@end itemize

@item
@code{guile-ssh}
@itemize
@item
git repository at GitHub: @uref{https://github.com/artyom-poptsov/guile-ssh}
@end itemize

@item
GNU Serveez
@itemize
@item
GNU software page: @uref{https://www.gnu.org/software/serveez/}
@item
manual: @uref{https://www.gnu.org/software/serveez/manual/}
@item
git repository at Savannah: @uref{http://savannah.gnu.org/projects/serveez/}
@end itemize

@item
@code{serveez-mg}
@itemize
@item
git repository at GitHub @uref{https://github.com/spk121/serveez-mg}
@item
based on GNU Serveez
@end itemize
@end itemize

@node Parallelism
@section Parallelism

@itemize
@item
standard library futures
@itemize
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile/docs/docs-2.2/guile-ref/Futures.html} (link to Guile 2.2 docs -- Where are the 3.x docs?)
@item
description:
@quotation
[@dots{}] a construct for fine-grain parallelism. A future is a wrapper around an expression whose computation may occur in parallel with the code of the calling thread, and possibly in parallel with other futures. Like promises, futures are essentially proxies that can be queried to obtain the value of the enclosed expression [@dots{}]

@end quotation
@end itemize

@item
@code{guile-fibers}
@itemize
@item
git repo: @uref{https://github.com/wingo/fibers}
@item
description:
@quotation
Concurrent ML-like concurrency for Guile

@end quotation
@end itemize

@item
standard library parallel forms
@itemize
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile/manual/html_node/Parallel-Forms.html}
@item
note: Sometimes the parallel forms might cause errors, see @uref{https://lists.gnu.org/archive/html/guile-user/2020-01/msg00092.html}, I recommend to use futures or if suitable @code{guile-fibers} instead.
@end itemize
@end itemize

@node Parsing
@section Parsing

@menu
* Parser Combinators::
* Parser Generator::
* Other: Other (4). 
@end menu

@node Parser Combinators
@subsection Parser Combinators

@itemize
@item
@code{stis-parser}
@itemize
@item
git repository at GitLab: @uref{https://gitlab.com/tampe/stis-parser}
@end itemize
@end itemize

@node Parser Generator
@subsection Parser Generator

@itemize
@item
@code{nyacc}: Not Yet Another Compiler Compiler
@itemize
@item
git repository at Savannah: @uref{https://savannah.nongnu.org/projects/nyacc}
@item
documentation: @uref{https://www.nongnu.org/nyacc/nyacc-ug.html}
@end itemize
@end itemize

@node Other (4)
@subsection Other

@itemize
@item
standard library PEG parsing
@itemize
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile/manual/html_node/PEG-Parsing.html}
@item
description:
@quotation
Parsing Expression Grammars (PEGs) are a way of specifying formal languages for text processing.

(@uref{https://www.gnu.org/software/guile/manual/html_node/PEG-Parsing.html})

@end quotation
@end itemize
@end itemize

@node Plotting
@section Plotting

@itemize
@item
@code{guile-plotutils}
@itemize
@item
git repository at GitHub: @uref{https://github.com/spk121/guile-plotutils}
@item
website: @uref{https://www.gnu.org/software/plotutils/plotutils.html}
@end itemize
@end itemize

@node Protocols
@section Protocols

@itemize
@item
X protocol
@itemize
@item
@code{guile-xcb}
@itemize
@item
git repo: @uref{https://github.com/mwitmer/guile-xcb}
@end itemize
@end itemize
@end itemize

@node Serialization formats
@section Serialization formats

@itemize
@item
@code{guile-msgpack}
@itemize
@item
git repo: @uref{https://gitlab.com/HiPhish/guile-msgpack}
@item
description:
@quotation
This is a GNU Guile library implementing the MessagePack data serialisation format. It allows you to serialise (pack) and de-serialise (unpack) Scheme objects to and from binary data according to the MessagePack format.

(@uref{https://gitlab.com/HiPhish/guile-msgpack/-/blob/master/README.rst})

@end quotation
@end itemize
@end itemize

@node SRFI (Scheme Request For Implementation) implementations
@section SRFI (Scheme Request For Implementation) implementations

@itemize
@item
@code{TaylanUB/scheme-srfis}
@itemize
@item
git repo: @uref{https://github.com/TaylanUB/scheme-srfis}
@item
description: This repository contains implementations for some SRFIs.
@end itemize
@end itemize

@node Strings
@section Strings

@itemize
@item
@code{guile-raw-strings}
@itemize
@item
git repo: @uref{https://github.com/lloda/guile-raw-strings}
@end itemize
@end itemize

@node Syntax
@section Syntax

@itemize
@item
(grand scheme) glossary
@itemize
@item
git repo: @uref{https://github.com/plande/grand-scheme}
@end itemize
@end itemize

@node Regular expressions
@section Regular expressions

@itemize
@item
IrRegular Expressions (Scheme, R[4567]RS)
@itemize
@item
website: @uref{http://synthcode.com/scheme/irregex}
@end itemize
@end itemize

@node REPL (Read Eval Print Loop)
@section REPL (Read Eval Print Loop)

@itemize
@item
@code{guile-colorized}
@itemize
@item
git repository at GitLab: @uref{https://gitlab.com/NalaGinrut/guile-colorized}
@end itemize
@end itemize

@node RPC (Remote Procedure Call)
@section RPC (Remote Procedure Call)

@itemize
@item
GNU Guile-RPC
@itemize
@item
website: @uref{https://www.gnu.org/software/guile-rpc/}
@item
documentation: @uref{https://www.gnu.org/software/guile-rpc/manual/}
@item
git repo: @uref{http://git.savannah.gnu.org/gitweb/?p=guile-rpc.git}
@end itemize

@item
@code{guile-xmlrpc}:
@itemize
@item
description:
@quotation
guile-xmlrpc is an XMLRPC module for Guile. Guile already has the wonderful sxml module that allows XML document creation and parsing. guile-xmlrpc goes one step further and combines sxml with some macros and procedures that simplifies even more the creation and parsing of XMLRPC documents.

(@uref{https://github.com/aconchillo/guile-xmlrpc/blob/master/README.org})

@end quotation
@item
git repo: @uref{https://github.com/aconchillo/guile-xmlrpc}
@item
manual: (readme file in git repo)
@end itemize
@end itemize

@node Scientific computing and mathematics
@section Scientific computing and mathematics

@itemize
@item
GNU Scientific Library (GSL)
@itemize
@item
GNU software page @uref{https://www.gnu.org/software/gsl/}
@item
git repository at Savannah: @uref{http://savannah.gnu.org/projects/gsl/}
@item
wikipedia page: @uref{https://en.wikipedia.org/wiki/GNU_Scientific_Library}
@item
Guile bindings: @uref{http://community.schemewiki.org/?gee-guile-gsl}
@end itemize

@item
Matrix multiplication
@itemize
@item
@code{guile-ffi-cblas}
@itemize
@item
git repository at GitHub: @uref{https://github.com/lloda/guile-ffi-cblas}
@end itemize
@end itemize

@item
Fast Fourier Transformation
@itemize
@item
@code{guile-ffi-fftw} by lloda
@itemize
@item
git repo: @uref{https://github.com/lloda/guile-ffi-fftw}
@item
description: @emph{"A simple wrapper for FFTW, using Guile's FFI"} (@uref{https://github.com/lloda/guile-ffi-fftw})
@end itemize
@item
@code{guile-ffi-fftw} by Mikael Djurfeldt
@itemize
@item
git repo at Savannah: @uref{https://savannah.nongnu.org/projects/guile-fftw}
@item
description:
@end itemize
@end itemize

@item
Symbolic mathematics
@itemize
@item
@code{guile-scmutils}
@itemize
@item
website: @uref{https://www.cs.rochester.edu/~gildea/guile-scmutils/}
@item
download: @uref{https://www.cs.rochester.edu/~gildea/guile-scmutils/guile-scmutils-v1.0.tgz}
@item
description:
@quotation
A port of the scmutils package for symbolic mathematics from mit scheme to guile, in an effort to make scmutils and the examples from the Structure and Interpretation of Classical Mechanics available on a wider variety of architectures/operating systems.

(@uref{https://www.cs.rochester.edu/~gildea/guile-scmutils/})

@end quotation
@end itemize
@end itemize

@item
Guile implementation of symbolic mathematics shown in SICP
@itemize
@item
Does this exist?
@end itemize
@end itemize

@menu
* Interaction with the Jupyter ecosystem::
@end menu

@node Interaction with the Jupyter ecosystem
@subsection Interaction with the Jupyter ecosystem

@itemize
@item
@code{guix-kernel}
@itemize
@item
git repository at gitlab.inria.fr: @uref{https://gitlab.inria.fr/guix-hpc/guix-kernel}
@item
blog post: @uref{https://hpc.guix.info/blog/2019/10/towards-reproducible-jupyter-notebooks/}
@end itemize

@item
@code{guile-kernel}
@itemize
@item
git repository at GitHub: @uref{https://github.com/jerry40/guile-kernel}
@end itemize
@end itemize

@node Search engine
@section Search engine

@itemize
@item
@code{babelia}
@itemize
@item
git repo: @uref{https://github.com/amirouche/babelia}
@item
description:
@quotation
Wanna be search engine with federation support

(@uref{https://github.com/amirouche/babelia})

@end quotation
@end itemize
@end itemize

@node TUI development
@section TUI development

@itemize
@item
@code{guile-ncurses}
@itemize
@item
GNU software page: @uref{https://www.gnu.org/software/guile-ncurses/}
@item
git repository at GitHub: @uref{https://github.com/guildhall/guile-ncurses}
@end itemize
@end itemize

@node Unit Testing
@section Unit Testing

@itemize
@item
SRFI-64 (@uref{https://srfi.schemers.org/srfi-64/srfi-64.html})
@itemize
@item
GNU software Guile manual page: @uref{https://www.gnu.org/software/guile/manual/html_node/SRFI_002d64.html}
@end itemize

@item
@code{srfi-64-driver}
@itemize
@item
git repository at: ???
@item
website: @uref{https://ngyro.com/software/srfi-64-driver.html}
@end itemize

@item
@code{guile-testing}
@itemize
@item
git repository at: @uref{https://github.com/wedesoft/guile-testing}
@item
description: @emph{"This is an example on how to do unit-testing using GNU Guile, Automake Test Anything Protocol (TAP), and SRFI-64."} (@uref{https://github.com/wedesoft/guile-testing/blob/598768b04fe9ef13e07401f1bd715f5fb3bb964e/README.md})
@end itemize
@end itemize

@menu
* TAP output::
@end menu

@node TAP output
@subsection TAP output

@itemize
@item
@code{guile-tap}
@itemize
@item
git repo: @uref{https://github.com/xevz/guile-tap}
@item
description: @emph{"Simple Guile module which provides TAP compilant output."} (@uref{https://github.com/xevz/guile-tap})
@end itemize

@item
@code{scm-test-tap}
@itemize
@item
git repo: @uref{https://github.com/ft/scm-test-tap}
@item
description: @emph{"TAP emitting test-framework for GNU Guile"} (@uref{https://github.com/ft/scm-test-tap})
@end itemize
@end itemize

@node Version control systems
@section Version control systems

@itemize
@item
@code{guile-git}
@itemize
@item
git repository at GitLab: @uref{https://gitlab.com/guile-git/guile-git}
@end itemize

@item
@code{guile-semver}
@itemize
@item
git repository at ngyro: @uref{https://git.ngyro.com/guile-semver}
@item
website at: @uref{https://ngyro.com/software/guile-semver.html}
@end itemize
@end itemize

@node Web Development
@section Web Development

@menu
* Web frameworks::
* Tooling / Additional libraries::
* Static website generators::
* Template engine::
* Interaction with services::
* Web application examples::
* Web drivers / Selenium::
@end menu

@node Web frameworks
@subsection Web frameworks

@itemize
@item
Guile's standard library's web module for dealing with web stuff:
@itemize
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile/manual/html_node/Web.html}
@end itemize

@item
Guile's standard library's web server:
@itemize
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile/manual/html_node/Web-Server.html}
@item
blog post about the performance of Guile's web server: @uref{http://wingolog.org/archives/2012/03/08/an-in-depth-look-at-the-performance-of-guiles-web-server}
@item
documentation as generic interface for web server implementations: @uref{https://www.gnu.org/software/guile/manual/html_node/Web-Server.html}
@item
examples for usage for creating a web app: @uref{https://www.gnu.org/software/guile/manual/html_node/Web-Examples.html#Web-Examples}
@end itemize

@item
GNU Artanis web application frameweork
@itemize
@item
GNU software page: @uref{https://www.gnu.org/software/artanis/}
@item
git repository at GitLab: @uref{https://gitlab.com/NalaGinrut/artanis}
@item
official website of the GNU Artanis project: @uref{https://web-artanis.com/}
@item
blog post about GNU Artanis: @uref{https://dev.to/heroku/an-ode-to-gnu-artanis-2gn3}
@item
manual:
@itemize
@item
@uref{https://www.gnu.org/software/artanis/manual/manual.html}
@item
@uref{https://www.gnu.org/software/artanis/manual/html_node/}
@end itemize
@item
blog post about using GNU Artanis in a docker container: @uref{https://nalaginrut.com/archives/2019/09/18/install%20gnu%20artanis%20with%20docker}
@end itemize

@item
SPH web app
@itemize
@item
git repository at GitHub: @uref{https://github.com/sph-mn/sph-web-app}
@end itemize

@item
Tekuti webglob using Git as its persistent store
@itemize
@item
git repository at GutHub: @uref{https://github.com/wingo/tekuti}
@item
blog post about tekuti: @uref{https://wingolog.org/projects/tekuti/}
@end itemize
@end itemize

@node Tooling / Additional libraries
@subsection Tooling / Additional libraries

@itemize
@item
JSON
@itemize
@item
@code{guile-json}
@itemize
@item
on GitHub: @uref{https://github.com/aconchillo/guile-json}
@item
on savannah: @uref{http://savannah.nongnu.org/projects/guile-json/}
@end itemize
@end itemize

@item
@code{guile-www}
@itemize
@item
git repository at savannah non-gnu: @uref{http://savannah.nongnu.org/projects/guile-www/}
@end itemize

@item
@code{guile-webutils}
@itemize
@item
git repository at notabug.org: @uref{https://notabug.org/cwebber/guile-webutils}
@end itemize

@item
@code{guile-html}
@itemize
@item
git repo: @uref{https://github.com/TaylanUB/guile-html}
@item
description:
@quotation
A tiny module to make it less annoying to make and write HTML files using SXML@. Read the code!

@end quotation
@end itemize
@end itemize

@enumerate
@item
Authorization and authentication


@itemize
@item
@code{guile-oauth}
@itemize
@item
git repository at GitHub: @uref{https://github.com/aconchillo/guile-oauth}
@end itemize

@item
@code{guile-jwt}
@itemize
@item
git repository on GitHub: @uref{https://github.com/aconchillo/guile-jwt}
@end itemize
@end itemize
@end enumerate

@node Static website generators
@subsection Static website generators

@itemize
@item
@code{guile-haunt}
@itemize
@item
git repository at GitHub: @uref{https://github.com/guildhall/guile-haunt}
@end itemize

@item
SPH static website generator
@itemize
@item
git repository at GitHub: @uref{https://github.com/sph-mn/sph-web-publish}
@end itemize
@end itemize

@node Template engine
@subsection Template engine

@itemize
@item
Guile's standard library SXML implementation
@itemize
@item
GNU software manual: @uref{https://www.gnu.org/software/guile/manual/html_node/SXML.html}
@item
Basically your templates become functions or macros.
@item
The structure of your document is kept as Scheme data structures.
@itemize
@item
This avoids having parse the document as a long string into an internal data structure to perform semantic transformations.
@item
It enables pattern matching without resorting to things like regular expressions and similar shenanigans.
@end itemize
@end itemize
@end itemize

@node Interaction with services
@subsection Interaction with services

@itemize
@item
@code{guile-mastodon}
@itemize
@item
git repository at framagit: @uref{https://framagit.org/prouby/guile-mastodon}
@item
documentation at: @uref{https://framagit.org/prouby/guile-mastodon/-/blob/master/doc/guile-mastodon.org}
@end itemize
@end itemize

@node Web application examples
@subsection Web application examples

@itemize
@item
@code{scheme-todomvc}:
@itemize
@item
git repo: @uref{https://github.com/amirouche/scheme-todomvc}
@item
demo: @uref{https://amirouche.github.io/scheme-todomvc/}
@end itemize
@end itemize

@node Web drivers / Selenium
@subsection Web drivers / Selenium

@itemize
@item
@code{guile-web-driver}
@itemize
@item
git repo: @uref{https://github.com/her01n/guile-web-driver}
@item
description: "web driver (selenium) client for guile" (@uref{https://github.com/her01n/guile-web-driver})
@end itemize
@end itemize

@node Window manager
@section Window manager

@itemize
@item
@code{guile-wm}
@itemize
@item
git repo: @uref{https://github.com/mwitmer/guile-wm}
@end itemize
@end itemize

@node Working with code
@section Working with code

@itemize
@item
@code{guile-syntax-highlight}
@itemize
@item
website: @uref{https://dthompson.us/projects/guile-syntax-highlight.html}
@item
repository: seems to be missing
@end itemize
@end itemize

@node Other
@section Other

@itemize
@item
@code{guile-lib}
@itemize
@item
git repository at non-GNU Savannah: @uref{http://git.savannah.nongnu.org/cgit/guile-lib.git}
@item
website at: @uref{https://www.nongnu.org/guile-lib/}
@item
description:
@quotation
guile-lib is intended as an accumulation place for pure-scheme Guile modules, allowing for people to cooperate integrating their generic Guile modules into a coherent library. Think "a down-scaled, limited-scope CPAN for Guile". [@dots{}]

(@uref{https://www.nongnu.org/guile-lib/})

@end quotation
@end itemize

@item
Spells
@itemize
@item
git repo: @uref{https://github.com/rotty/spells}
@item
description:
@quotation
Spells is a collection of R6RS libraries providing features beyond R6RS in a uniform way across supported implementations.

(@uref{https://github.com/rotty/spells/blob/master/README})

@end quotation
@item
documentation: @uref{http://rotty.xx.vu/software/spells/} (unfortunately 404 currently)
@end itemize

@item
SPH website:
@itemize
@item
It has some Guile library and project descriptions and links.
@item
@uref{http://sph.mn/}
@end itemize
@end itemize

@node Projects
@chapter Projects

@itemize
@item
Guile 100
@itemize
@item
description:
@quotation
This is the repository for the Guile 100 Programs project. This is a collaborative effort to create a set of examples on how Guile might be used for real-world problems.

(@uref{https://github.com/spk121/guile100/blob/master/README.md})

@end quotation
@item
git repo: @uref{https://github.com/spk121/guile100/}
@item
website: @uref{http://www.lonelycactus.com/guile100/html/index.html}
@end itemize
@end itemize

@node Programming paradigm
@chapter Programming paradigm

@menu
* "Object-oriented programming"::
* Relational programming::
* Functional programming::
@end menu

@node "Object-oriented programming"
@section "Object-oriented programming"

@itemize
@item
GOOPS
@itemize
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile/manual/html_node/GOOPS.html}
@end itemize
@end itemize

@menu
* Prototype based::
@end menu

@node Prototype based
@subsection Prototype based

@itemize
@item
Shelf
@itemize
@item
git repo: @uref{https://github.com/mwitmer/Shelf}
@end itemize
@end itemize

@node Relational programming
@section Relational programming

@itemize
@item
@code{minikanren}
@itemize
@item
git repository at GitHub: @uref{https://github.com/ijp/minikanren}
@item
miniKanren uncourse by William Byrd: @uref{https://duckduckgo.com/?q=minikanren+uncourse&t=h_&iax=videos&ia=videos&iai=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DiCuVTGWNU3s}
@end itemize
@end itemize

@node Functional programming
@section Functional programming

@itemize
@item
Monad implementations
@itemize
@item
git repository at GitHub: @uref{https://github.com/ijp/monad}
@end itemize
@end itemize

@node Tools
@chapter Tools

@menu
* Editor support::
* Project management::
@end menu

@node Editor support
@section Editor support

@itemize
@item
@code{guile.vim}
@itemize
@item
git repo: @uref{https://gitlab.com/HiPhish/guile.vim}
@item
description:
@quotation
This plugin extends Vim's Scheme support to include the additions to the language provided by the GNU Guile implementation. The plugin automatically detects whether a Scheme file is a Guile file and adds syntax highlighting for Guile's special forms.

(@uref{https://gitlab.com/HiPhish/guile.vim/-/blob/master/README.rst})

@end quotation
@end itemize

@item
@code{repl.nvim}
@itemize
@item
git repo: @uref{https://gitlab.com/HiPhish/repl.nvim/}
@item
description:
@quotation
REPL.nvim bring REPL support to Nvim! Use the built-in REPLs, add your own, or change the existing ones. Change settings in your init.vim or on the fly, make them global or local, use the existing ones or make your own.

(@uref{https://gitlab.com/HiPhish/repl.nvim/-/blob/master/README.rst})

@end quotation
@end itemize

@item
TODO: Emacs Guile support

@item
TODO: other editors support
@end itemize

@node Project management
@section Project management

@itemize
@item
@code{guile-hall}
@itemize
@item
git repository at GitLab: @uref{https://gitlab.com/a-sassmannshausen/guile-hall}
@end itemize

@item
@code{homebrew-guile}: @uref{https://github.com/aconchillo/}

@item
@code{guile-debbugs}
@itemize
@item
git repo: @uref{http://savannah.gnu.org/git/?group=guile-debbugs}
@item
description: see @uref{http://git.savannah.nongnu.org/cgit/guile-debbugs.git/tree/README.org}
@end itemize
@end itemize

@menu
* Package managers::
@end menu

@node Package managers
@subsection Package managers

@itemize
@item
GUIX package search
@itemize
@item
website: @uref{https://hpc.guix.info/browse}
@item
Search for example for @code{^guile-} to find many Guile libraries and projects.
@end itemize

@item
@code{guildhall}
@itemize
@item
git repository at GitHub: @uref{https://github.com/ijp/guildhall}
@end itemize

@item
Akku
@itemize
@item
website: @uref{https://akkuscm.org/}
@item
description:
@quotation
Akku.scm is a language package manager for Scheme. It grabs hold of code and vigorously shakes it until it behaves properly.

(@uref{https://akkuscm.org/})

@end quotation
@end itemize
@end itemize

@node Blogs
@chapter Blogs

@itemize
@item
@uref{https://hyper.dev/}
@item
@uref{http://wingolog.org/}
@item
@uref{http://okmij.org/ftp/Scheme/}
@item
blog post about singletons in GNU Guile
@itemize
@item
website: @uref{http://hiphish.github.io/blog/2019/05/24/singleton-objects-in-guile-scheme/}
@end itemize
@end itemize

@node Other (5)
@chapter Other

@itemize
@item
SPH lib, collection of Guile libraries
@itemize
@item
website: @uref{http://sph.mn/computer/software/sph-lib.html}
@end itemize

@item
C2 Wiki Category Scheme
@itemize
@item
website: @uref{https://proxy.c2.com/cgi/wiki?CategoryScheme}
@end itemize

@item
C2 Wiki Guile Scheme
@itemize
@item
website: @uref{https://proxy.c2.com/cgi/wiki?GuileScheme}
@end itemize

@item
C2 Wiki Scheme Language
@itemize
@item
website: @uref{https://proxy.c2.com/cgi/wiki?SchemeLanguage}
@end itemize

@item
Community Scheme Wiki
@itemize
@item
general
@itemize
@item
website: @uref{http://community.schemewiki.org}
@end itemize
@item
Scheme FAQ
@itemize
@item
website: @uref{http://community.schemewiki.org/?scheme-faq-standards}
@end itemize
@end itemize

@item
SICP solutions
@itemize
@item
git repo: @uref{https://github.com/alpardal/SICP-guile}
@item
description:
@quotation
A SICP Study Guide With Exercise Solutions in Guile & Emacs Lisp

(@uref{https://github.com/alpardal/SICP-guile})

@end quotation
@end itemize
@end itemize

@node Other lists of Guile software
@chapter Other lists of Guile software

@itemize
@item
official GNU Guile website library list: @uref{https://www.gnu.org/software/guile/libraries/}
@item
SPH list: @uref{http://sph.mn/foreign/guile-software.html}
@end itemize

@node Videos / Talks / Presentations
@chapter Videos / Talks / Presentations

This category is still empty. Help filling it with interesting GNU Guile related videos, talks or presentations!

@bye